package com.ddm.service.impl.webImpl;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ddm.entity.webEntity.Course;
import com.ddm.mapper.BookmarkMapper;
import com.ddm.mapper.CourseMapper;
import com.ddm.service.webService.CourseService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

@Slf4j
@Service
public class CourseServiceImpl extends ServiceImpl<CourseMapper, Course> implements CourseService {

    @Autowired
    private CourseMapper courseMapper;

    @Autowired
    private BookmarkMapper bookmarkMapper;

    @Override
    public Boolean add(Course course) {
        // 检查对象是否为空
        if (course == null) {
            return false;
        }

        // 检查必填字段
        if (course.getVideoName() == null || course.getVideoName().trim().isEmpty()) {
            return false;
        }

        if (course.getVideoUrl() == null || course.getVideoUrl().trim().isEmpty()) {
            return false;
        }

        if (course.getVideoPublishDate() == null) {
            return false;
        }

        if (course.getVideoAuthor() == null || course.getVideoAuthor().trim().isEmpty()) {
            return false;
        }


            save(course);  // 执行保存
            Course savedCourse = getById(course.getId());  // 通过ID查询数据
            return savedCourse != null;  // 存在即返回true


    }



    @Override
    public Boolean update(Course course) {
        if (course == null || course.getId() == null) {
            return false;
        }
        return updateById(course);
    }

    @Override
    public Boolean delete(Integer id) {
        if (id == null || id <= 0) {
            return false;
        }
        return removeById(id);
    }

    @Override
    public Course getCourseById(Integer id) {
        return courseMapper.selectById(id);
    }

    @Override
    public IPage<Course> getCourseByType(Page<Course> page, String type) {
        return null;
    }

//    @Override
//    public IPage<Course> getCourseByType(String type, Integer pageNum, Integer pageSize) {
//        Page<Course> page = new Page<>(pageNum, pageSize);
//        return courseMapper.selectBytype(page, type);
//    }

    @Override
    public IPage<Course> getCoursesByType(Page<Course> page, String type) {
        QueryWrapper<Course> wrapper = new QueryWrapper<>();
        LambdaQueryWrapper<Course> lambdaWrapper = wrapper.lambda();

        if (type != null && !type.isEmpty()) {
            // 使用OR连接多个字段的精准查询
            lambdaWrapper.eq(Course::getType, type);
        }

        return this.page(page, lambdaWrapper);
    }
//
//    @Override
//    public IPage<Course> getCoursesByIds(List<Integer> ids, Page<Course> page) {
//            if (CollectionUtils.isEmpty(ids)) {
//                return new Page<>(); // 返回空分页对象
//            }
//            // 创建查询条件
//            QueryWrapper<Course> wrapper = new QueryWrapper<>();
//            wrapper.in("id", ids); // 查询ID在列表中的记录
//            // 执行分页查询
//            return courseMapper.selectPage(page, wrapper);
//    }


//    @Override
//    public List<Course> getAllCourses() {
//        QueryWrapper<Course> queryWrapper = new QueryWrapper<>();
//        return courseMapper.selectList(queryWrapper);
//    }

    @Override
    public IPage<Course> getCoursesByPage(Page<Course> page, String key) {
        QueryWrapper<Course> wrapper = new QueryWrapper<>();
        LambdaQueryWrapper<Course> lambdaWrapper = wrapper.lambda();

        if (key != null && !key.isEmpty()) {
            // 使用OR连接多个字段的模糊查询
            lambdaWrapper
                    .like(Course::getVideoName, key)
                    .or().like(Course::getVideoAuthor, key)
                    .or().like(Course::getVideoAbstract, key);
        }

        return this.page(page, lambdaWrapper);
    }



    /**
     * 根据用户收藏数据返回课程
     * @return
     */
    @Override
    public IPage<Course> getCollectedCoursesByUserId(Page<Course> page, Integer userId, String key) {
        // 打印方法入参，确认分页参数、用户ID和关键词
        log.info("开始查询用户收藏课程 | userId: {}, 页码: {}, 每页条数: {}, 关键词: {}",
                userId, page.getCurrent(), page.getSize(), key);

        // 1. 查询用户收藏的所有course_id
        log.info("Step 1: 查询用户[{}]收藏的course_id列表", userId);
        List<Integer> courseIds = bookmarkMapper.selectCourseIdsByUserId(userId);
        // 过滤掉null值
        courseIds = courseIds.stream()
                .filter(Objects::nonNull) // 保留非null的id
                .collect(Collectors.toList());
        log.info("Step 1结果: 收藏的course_id数量为: {}", courseIds != null ? courseIds.size() : 0);
        if (!CollectionUtils.isEmpty(courseIds)) {
            log.info("Step 1详情: 收藏的course_id列表: {}", courseIds); // 仅调试用
        }

        // 2. 处理无收藏课程情况，返回包含分页参数的空结果
        if (CollectionUtils.isEmpty(courseIds)) {
            log.info("Step 2: 用户[{}]无收藏课程，返回空分页", userId);
            Page<Course> emptyPage = new Page<>(page.getCurrent(), page.getSize());
            emptyPage.setTotal(0);
            return emptyPage;
        }

        // 3. 构造查询条件：先锁定收藏课程范围，再做关键词搜索
        log.info("Step 3: 构造查询条件 | 关键词: {}", key);
        LambdaQueryWrapper<Course> lambdaWrapper = new LambdaQueryWrapper<>();
        lambdaWrapper.in(Course::getId, courseIds)
                .last(""); // 清除 MyBatis-Plus 自动添加的 WHERE deleted=0

        log.info("Step 3条件: 已添加收藏课程ID范围筛选（共{}个ID）", courseIds.size());

        if (StrUtil.isNotBlank(key)) {
            // 关键修改：用and()包裹所有OR条件，确保与IN条件形成"且"的关系
            lambdaWrapper.and(wrapper -> wrapper
                    .like(Course::getVideoName, key)
                    .or()
                    .like(Course::getVideoAuthor, key)
                    .or()
                    .like(Course::getVideoAbstract, key)
            );
            log.info("Step 3条件: 已添加关键词[{}]的模糊查询（匹配视频名、作者、摘要）", key);
        } else {
            log.info("Step 3条件: 无关键词，仅查询收藏课程");
        }

        // 4. 分页查询
        log.info("Step 4: 执行分页查询 | SQL条件: {}", lambdaWrapper.getSqlSegment()); // 打印SQL条件片段
        IPage<Course> resultPage = baseMapper.selectPage(page, lambdaWrapper);

        // 打印查询结果
        log.info("Step 4结果: 总记录数: {}, 当前页记录数: {}, 页码: {}",
                resultPage.getTotal(),
                resultPage.getRecords().size(),
                resultPage.getCurrent());

        return resultPage;
    }
}